import {isString} from "@/common/common";
import config from "@/uni_modules/u-tools/libs/config";

/**
 * 格式化进制单位的显示
 * @param {string | number} value 处理的数据
 * @param {number} formatType 需要格式化的类型
 * @param {number} precision 需要保留的小数精度
 * */
export const format = function(value: string | number, formatType: number, precision?: number): string
{
    if (value != null)
    {
        // 判断是否为空,为空则原值返回
        if (isString(value) && value === "")
        {
            return value;
        }

        // 格式化时保留的小数精度
        precision = precision || 2;

        // 获取当前的格式化单位
        const unit = getFormatUnit(formatType);

        // 获取格式化值
        return getFormatDataByUnit(value, unit, formatType, precision) || "";
    }
    else
    {
        return "";
    }
};

/**
 * 暂停执行函数
 * @param {number} millis 需要暂停的时间
 * 使用示例：
 * const fn = async () =>
 * {
 *      await pause(1000);
 * };
 * */
export const pause = function(millis: number): Promise<any>
{
    return new Promise(resolve =>
    {
        setTimeout(resolve, millis);
    });
};

/**
 * 等待函数
 * @param {function} fn 回调函数
 * @param {number} millis 延迟执行的毫秒数
 * */
export const asyncFn = async function(fn: Function, millis: number): Promise<any>
{
    await pause(millis);

    return fn();
};

/**
 * 获取格式化单位
 * @param {number} formatType 需要格式化的类型
 * */
export const getFormatUnit = function(formatType: number): Record<string, any>
{
    // 格式化单位map
    const unitMap: Record<string, any> = {
        // 格式化金额
        1: {
            decimal: 10000, unit: ["元", "万", "亿"]
        }
    };

    return unitMap[formatType];
};

/**
 * 根据单位获取格式化值
 * @param {number} value 需要格式化的值
 * @param {object} unit 需要格式化的单位
 * @param {number} formatType 需要格式化的类型
 * @param {number} precision 需要保留的小数精度
 * */
export const getFormatDataByUnit = function(value: string | number, unit: Record<string, any>, formatType: number, precision: number): string
{
    let data = "";

    switch (formatType)
    {
        // 格式化金额单位
        case 1:
        {
            data = formatPrice(translateNumber(value), unit);

            break;
        }
        // 格式化电话
        case 2:
        {
            data = formatMobile(value.toString());

            break;
        }
        // 格式化金额
        case 3:
        {
            data = formatAmount(translateString(value));

            break;
        }
        // 格式化名字
        case 4:
        {
            data = formatName(value.toString());

            break;
        }
        // 其他
        default:
        {
            break;
        }
    }

    return data;

    // 转化值为数字类型
    function translateNumber(value: string | number): number
    {
        let formatNumber: number;

        // 验证值
        if (isString(value))
        {
            const itemValue = value as string;

            if (!isNaN(Number(itemValue)))
            {
                formatNumber = Number(itemValue);
            }
            else
            {
                throw new Error("格式化值类型错误");
            }
        }
        else if (isNumber(value))
        {
            formatNumber = value as number;
        }
        else
        {
            throw new Error("格式化值类型错误");
        }

        return formatNumber;
    }

    // 转化值为字符串类型
    function translateString(value: string | number): string
    {
        let formatString: string;

        // 验证值
        if (isString(value))
        {
            const itemValue = value as string;

            if (!isNaN(Number(itemValue)))
            {
                formatString = itemValue;
            }
            else
            {
                throw new Error("格式化值类型错误");
            }
        }
        else
        {
            formatString = value.toString();
        }

        return formatString;
    }

    // 格式化金额单位
    function formatPrice(value: number, unit: Record<string, any>): string
    {
        // 验证单位
        if (unit)
        {
            if (value >= 1)
            {
                const index = Math.floor(Math.log(value) / Math.log(unit.decimal));

                const size = value / Math.pow(unit.decimal, index);

                // 如果当前格式化出来的转化数据的小数大于了设置的精度值,则不转化,比如1.1111万,设置的精度值只有2位,那么在显示的时候因为只会显示2位,那么就会造成误解.
                const decimal = size.toString().split(".")[1];

                if (decimal && decimal.length > precision)
                {
                    return `${formatFloat(value, precision)}${unit.unit[0]}`;
                }
                else
                {
                    return `${formatFloat(size, precision)}${unit.unit[index]}`;
                }
            }
            else
            {
                return `${formatFloat(value, precision)}${unit.unit[0]}`;
            }
        }
        else
        {
            throw new Error("格式化单位错误");
        }
    }

    // 格式化金额
    function formatAmount(value: string): string
    {
        // 分离整数部分和小数部分
        const parts = value.split(".");

        // 整数部分
        let integerPart = parts[0];

        // 小数部分
        const decimalPart = parts[1] ? "." + parts[1] : "";

        // 添加千位分隔符
        integerPart = integerPart.replace(/\B(?=(\d{3})+(?!\d))/g, ",");

        // 返回格式化的金额
        return integerPart + decimalPart;
    }

    // 格式化电话
    function formatMobile(value: string): string
    {
        // 将电话号码第四位开始到第七位的数据进行隐藏
        return value.slice(0, 3) + "****" + value.slice(7);
    }

    // 格式化名字
    function formatName(value: string): string
    {
        // 获取名字的长度
        const length = value.length;

        // 根据名字长度进行脱敏处理
        if (length === 2)
        {
            // 两个字符的情况
            return value.charAt(0) + "*";
        }
        else if (length > 2)
        {
            // 三个或更多字符的情况
            return value.charAt(0) + "*".repeat(length - 2) + value.charAt(length - 1);
        }
        else
        {
            // 单个字符的情况
            return value;
        }
    }
};

/**
 * 保留小数位数
 * @param {string | number} value 处理的数据
 * @param {number} length 保留的小数位数,默认: 2
 * @param {boolean} hasZero 是否保留最后一位为0的数, 默认: true
 * @param {mode} mode 格式化方式（round: 舍入 cut：裁剪） 默认： round
 * */
export const formatFloat = function(value: string | number, length?: number, hasZero?: boolean, mode?: string): string
{
    // 小数位
    let decimal = 2;

    if (value != null && isString(value))
    {
        // 转化为浮点型
        value = parseFloat(value);
    }

    if (length && length >= 0)
    {
        decimal = length;
    }

    hasZero = hasZero ?? true;

    mode = mode ?? "round";

    return formatNumber(value, decimal, hasZero);

    function formatNumber(number: number, exponent: number, hasZero: boolean): string
    {
        if (number != null)
        {
            // 如果当前保留小数位数的值小于0，则原值返回
            if (exponent < 0)
            {
                return number.toString();
            }
            else
            {
                let fixedNumber;

                // 舍入
                if (mode && mode === "round")
                {
                    fixedNumber = toFixedMathRound(number, exponent, hasZero);
                }
                // 裁剪
                else
                {
                    fixedNumber = toFixedChop(number, exponent, hasZero);
                }

                return fixedNumber;
            }
        }
        else
        {
            return "";
        }
    }

    // 给定数字的值四舍五入到最接近的整数
    function toFixedMathRound(number: number, exponent: number, hasZero: boolean): string
    {
        number = Math.round(number * Math.pow(10, exponent)) / Math.pow(10, exponent);

        let formatNumber: string = number.toFixed(exponent).toString();

        if (hasZero)
        {
            return formatNumber;
        }
        else
        {
            const formatArray: RegExpMatchArray | null = formatNumber.match(/\d+\.\d+/g);

            if (formatArray && formatArray.length)
            {
                formatArray.forEach((item: string) =>
                {
                    formatNumber = formatNumber.replace(item, parseFloat(item).toString());
                });
            }

            return formatNumber;
        }
    }

    // 直接斩断保留位数之后的数字
    function toFixedChop(number: number, exponent: number, hasZero: boolean): string
    {
        // 小数点之前的数
        let beforePoint = "";

        // 小数点之后的数
        let afterPoint = "";

        // 格式化数字
        let formatNumber = "";

        // 格式化数字
        const splitNumber: string[] = number.toString().split(".");

        if (splitNumber[0])
        {
            beforePoint = splitNumber[0];
        }

        // 判断有没有小数位
        if (splitNumber[1])
        {
            // 先截取指定的长度
            let pointNumber: string = splitNumber[1].substring(0, exponent);

            // 判断是否需要保留0
            if (hasZero)
            {
                if (pointNumber.length < exponent)
                {
                    // 计算需要补位的个数
                    const diffCount = exponent - pointNumber.length;

                    for (let i = 0; i < diffCount; i++)
                    {
                        pointNumber = pointNumber + "0";
                    }

                    afterPoint = pointNumber;
                }
                else
                {
                    afterPoint = pointNumber;
                }
            }
            else
            {
                afterPoint = pointNumber;
            }
        }
        else
        {
            // 判断是不是需要保留0
            if (hasZero)
            {
                for (let i = 0; i < exponent; i++)
                {
                    afterPoint = afterPoint + "0";
                }
            }
        }

        if (beforePoint && afterPoint)
        {
            formatNumber = `${beforePoint}.${afterPoint}`;
        }
        else if (beforePoint && !afterPoint)
        {
            formatNumber = `${beforePoint}`;
        }

        return formatNumber;
    }
};

/**
 * 函数节流(某一高频事件被触发时，确保在每一个特定的时间段内被执行一次)
 * @param {function} fn 传递需要执行的函数
 * @param {number} delay 当前节流间隔周期
 * */
export const throttle = function(fn: Function, delay?: number)
{
    // 间隔时间
    delay = delay ?? 500;

    // 标记
    let flag = true;

    return (...args: any) =>
    {
        if (flag)
        {
            flag = false;

            fn(...args);

            // 如果没有节流时间
            if (delay)
            {
                setTimeout(() =>
                {
                    flag = true;
                }, delay);
            }
            else
            {
                flag = true;
            }
        }
    };
};

/**
 * 函数防抖(某一高频事件不断被触发时，仅在最后一次真正执行事件处理代码)
 * @param {function} fn 传递需要执行的函数
 * @param {number} time 当前防抖间隔周期
 * @param {boolean} immediate 是否立即执行
 * */
export const debounce = (fn: Function, time?: number, immediate?: boolean) =>
{
    // 时间间隔
    time = time ?? 500;

    // 是否立即执行
    immediate = immediate ?? false;

    // 当前时间机制
    let timer: ReturnType<typeof setTimeout> = 0;

    // 当前的标记
    let flag = true;

    return function(this: any, ...args: any[])
    {
        // 保存上下文环境和参数
        const _this = this;

        if (timer)
        {
            clearTimeout(timer);
        }

        // 判断是否需要立即执行
        if (immediate)
        {
            if (flag)
            {
                fn.apply(_this, args);

                flag = false;
            }
        }

        // 将外部传入的函数的执行放在setTimeout中
        timer = setTimeout(() =>
        {
            // 执行后则清掉时间机制
            clearTimeout(timer);

            fn.apply(_this, args);

            // 判断是否需要立即执行
            if (immediate)
            {
                flag = true;
            }

        }, time);
    };
};

/**
 * @description 读取缓存(默认同步获取)
 * @param {string} key 传递的key
 * @param {boolean} sync 同步&异步模式
 * */
export const getStorage = function(key: string, sync?: boolean): Promise<any> | any
{
    if (isString(key))
    {
        if (key)
        {
            // 同步模式
            if (!sync)
            {
                return uni.getStorageSync(key);
            }
            else
            {
                return new Promise((resolve, reject) =>
                {
                    uni.getStorage({
                        key,
                        success: res =>
                        {
                            resolve(res.data);
                        },
                        fail: error =>
                        {
                            reject(error);
                        }
                    });
                });
            }
        }
        else
        {
            throw new Error("请传入正确的缓存key");
        }
    }
    else
    {
        throw new Error("请传入正确的缓存key");
    }
};

/**
 * @description 设置缓存(默认同步模式)
 * @param {string} key 传递的key
 * @param {object} data 缓存的值
 * @param {boolean} sync 同步&异步模式
 * */
export const setStorage = function(key: string, data: any, sync?: boolean): Promise<any> | void
{
    if (isString(key))
    {
        if (key)
        {
            if (data != null)
            {
                // 同步模式
                if (!sync)
                {
                    uni.setStorageSync(key, data);
                }
                else
                {
                    return new Promise((resolve, reject) =>
                    {
                        uni.setStorage({
                            key,
                            data,
                            success: res =>
                            {
                                resolve(res);
                            },
                            fail: error =>
                            {
                                reject(error);
                            }
                        });
                    });
                }
            }
            else
            {
                throw new Error("请传入缓存的数据");
            }
        }
        else
        {
            throw new Error("请传入正确的缓存key");
        }
    }
    else
    {
        throw new Error("请传入正确的缓存key");
    }
};

/**
 * @description 移除缓存(默认同步模式)
 * @param {string} key 传递的key
 * @param {boolean} sync 同步&异步模式
 * */
export const removeStorage = function(key: string, sync?: boolean): Promise<any> | void
{
    if (isString(key))
    {
        if (key)
        {
            // 同步模式
            if (!sync)
            {
                uni.removeStorageSync(key);
            }
            else
            {
                return new Promise((resolve, reject) =>
                {
                    uni.removeStorage({
                        key,
                        success: res =>
                        {
                            resolve(res);
                        },
                        fail: error =>
                        {
                            reject(error);
                        }
                    });
                });
            }
        }
        else
        {
            throw new Error("请传入正确的缓存key");
        }
    }
    else
    {
        throw new Error("请传入正确的缓存key");
    }
};

/**
 * @description 读取extJson配置
 * */
export const getExtStore = function(): Record<string, any>
{
    try
    {
        return uni.getExtConfigSync?.() ?? {};
    }
    catch (error: any)
    {
        throw new Error(error);
    }
};

/**
 * @description 去除空格
 * @param {string} str 需要去除空格的字符串
 * @param {string} pos both(左右)|left|right|all 默认both
 */
export const trim = function(str: string, pos: string = "both"): string
{
    if (str)
    {
        if (pos === "both")
        {
            return str.replace(/^\s+|\s+$/g, "");
        }
        if (pos === "left")
        {
            return str.replace(/^\s*/, "");
        }
        if (pos === "right")
        {
            return str.replace(/(\s*$)/g, "");
        }
        if (pos === "all")
        {
            return str.replace(/\s+/g, "");
        }
    }

    return str;
};

/**
 * 克隆对象
 * @param {array | object} value 克隆的对象
 * @param {boolean} deep 是否深度拷贝 默认: false 浅拷贝
 * */
export const clone = function <T>(value: T, deep?: boolean): T
{
    let cloneData: any;

    deep = deep ?? false;

    if (isArray(value))
    {
        const itemValue = value as Array<any>;

        if (deep)
        {
            cloneData = deepClone(itemValue);
        }
        else
        {
            cloneData = Object.assign([], itemValue);
        }
    }
    else if (isObject(value))
    {
        const itemValue = value as Record<string, any>;

        if (deep)
        {
            cloneData = deepClone(itemValue);
        }
        else
        {
            cloneData = Object.assign({}, itemValue);
        }
    }
    else
    {
        cloneData = value;
    }

    return cloneData;

    // 递归深度拷贝
    function deepClone<T>(target: T): T
    {
        // 手写深度拷贝
        let result: any;

        if (isArray(target))
        {
            result = [];
        }
        else if (isObject(target))
        {
            result = {};
        }
        else
        {
            return target;
        }

        // 遍历目标数据
        for (const i in target as T)
        {
            // 获取遍历数据结构的每一项值
            const value = target[i];

            // 判断目标结构里的每一项值是否存在对象/数组
            if (isArray(value) || isObject(value))
            {
                // 对象/数组里嵌套了对象/数组
                result[i] = deepClone(value);
            }
            else
            {
                // 获取到value值是基本的数据类型或者是函数
                result[i] = value;
            }
        }

        return result;

        // 但是json转换的方法有一个致命的缺陷，如果对象中有value的值是undefined，这样拷贝的时候会直接把value为undefined的键值对给删掉
        // return JSON.parse(JSON.stringify(target));
    }
};

/**
 * Bem风格样式名格式化
 * @param {string} name 组件名
 * @param {array} modifier 组件状态
 * @return {string} 样式名
 * */
export function bem(name: string, modifier: string[]): string
{
    let str = `u-${name} `;

    if (modifier && modifier.length)
    {
        modifier.forEach((item: string) =>
        {
            if (item)
            {
                str += `u-${name}-${item} `;
            }
        });
    }

    return str.trim();
}

/**
 * 当前数值的单位
 * @param {string | number} value 需要带单位的数值
 * @param {string} unit 单位
 * @returns {string} 返回带单位的数值
 * */
export function unit(value: string | number, unit: string = ""): string
{
    unit = unit || config.unit;

    if (value && isString(value))
    {
        if (!isNaN(Number(value)))
        {
            value = value + unit;
        }
    }
    else if (isNumber(value))
    {
        value = value + unit;
    }

    return value;
}

/**
 * 获取两个颜色之间的渐变颜色
 * @param {string} startColor 开始的颜色
 * @param {string} endColor 结束的颜色
 * @param {number} percent 进度百分比（1-00）
 * @returns {string} 返回渐变颜色
 * */
export function getGradientColor(startColor: string, endColor: string, percent: number = 10): string[]
{
    // 获取开始颜色RGBA值
    const startColorRGB = hexToRGB(startColor);

    // 获取结束颜色RGBA值
    const endColorRGB = hexToRGB(endColor);

    // 存储渐变颜色
    const colorArray: string[] = [];

    if (startColorRGB && endColorRGB)
    {
        // 获取开始颜色RGB值
        const startR: number = startColorRGB.r;
        const startG: number = startColorRGB.g;
        const startB: number = startColorRGB.b;
        const startA: number = startColorRGB.a;

        // 获取结束颜色RGB值
        const endR: number = endColorRGB.r;
        const endG: number = endColorRGB.g;
        const endB: number = endColorRGB.b;
        const endA: number = endColorRGB.a;

        // R值步长
        const sR: number = (endR - startR) / percent;

        // G值步长
        const sG: number = (endG - startG) / percent;

        // B值步长
        const sB: number = (endB - startB) / percent;

        // A值步长
        const sA: number = (endA - startA) / percent;

        for (let i = 0; i < percent; i++)
        {
            // 计算每一步的hex值
            let hex = rgbToHEX(`rgba(${Math.round(sR * i + startR)}, ${Math.round(sG * i + startG)}, ${Math.round(sB * i + startB)}, ${sA === 0 ? 1 : (sA * i).toFixed(2)})`);

            if (i === 0)
            {
                hex = rgbToHEX(startColor);
            }
            else if (i === percent - 1)
            {
                hex = rgbToHEX(endColor);
            }

            colorArray.push(hex);
        }
    }

    return colorArray;
}

/**
 * 获取HEX表示方式转化为RGB表示方式
 * @param {string} hex 十六进制颜色值
 * @returns {string} 返回RGB表示方式
 * */
export function hexToRGB(hex: string): {r: number, g: number, b: number, a: number} | null
{
    hex = String(hex).toLocaleLowerCase();

    const reg: RegExp = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;

    // 判断是否为合法的十六进制颜色码
    if (hex && reg.test(hex))
    {
        // 去除可能存在的#号
        hex = hex.replace(/^#/, "");

        // 处理3位和6位的十六进制颜色码
        if (hex.length === 3)
        {
            hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
        }
        else if (hex.length !== 6)
        {
            // 非法的十六进制颜色码
            return null;
        }

        // 解析RGB值
        const r = parseInt(hex.slice(0, 2), 16);
        const g = parseInt(hex.slice(2, 4), 16);
        const b = parseInt(hex.slice(4, 6), 16);
        const a = 1;

        return {r, g, b, a};
    }
    // 处理RGB表示方式
    else if (/^(rgba|rgb)/.test(hex))
    {
        const hexArray: string[] = hex.replace(/(?:\(|\)|rgba|rgb)*/g, "").split(",");

        if (hexArray.length === 3)
        {
            return {r: parseFloat(hexArray[0]), g: parseFloat(hexArray[1]), b: parseFloat(hexArray[2]), a: 1};
        }
        else if (hexArray.length === 4)
        {
            return {r: parseFloat(hexArray[0]), g: parseFloat(hexArray[1]), b: parseFloat(hexArray[2]), a: parseFloat(hexArray[3])};
        }
    }

    return null;
}

/**
 * 获取RGB表示方式转化为HEX表示方式
 * @param {string} rgb RGB表示方式
 * @returns {string} 返回HEX表示方式
 * */
export function rgbToHEX(rgb: string): string
{
    rgb = rgb.toLocaleLowerCase();

    const reg: RegExp = /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;

    if (/^(rgba|rgb)/.test(rgb))
    {
        const hexArray: string[] = rgb.replace(/(?:\(|\)|rgba|rgb)*/g, "").split(",");

        const r = parseInt(hexArray[0], 10);
        const g = parseInt(hexArray[1], 10);
        const b = parseInt(hexArray[2], 10);
        const a = hexArray[3] ? parseFloat(hexArray[3]) : 1;

        // 将RGB值转换为HEX
        const hex = ((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1);

        // 如果透明度不是1，则返回rgba格式的HEX
        if (a < 1)
        {
            return `#${hex}${Math.round(a * 255).toString(16).padStart(2, "0")}`;
        }

        return `#${hex}`;
    }
    else if (reg.test(rgb))
    {
        const hexArray: string[] = rgb.replace(/#/, "").split("");

        if (hexArray.length === 3)
        {
            rgb = "#" + hexArray[0] + hexArray[0] + hexArray[1] + hexArray[1] + hexArray[2] + hexArray[2];
        }
        else if (hexArray.length === 6)
        {
            rgb = "#" + hexArray.join("");
        }
    }

    return rgb;
}

/**
 * 当前小程序胶囊的几何信息
 * @returns {object} 胶囊的几何信息
 * */
export function getCapsuleGeometry(): {top: number, left: number, width: number, height: number; bottom: number; right: number;}
{
    // 当前胶囊的结合数据
    const geometry: {top: number, left: number, width: number, height: number; bottom: number; right: number;} = {
        top: 0,
        left: 0,
        width: 0,
        height: 0,
        bottom: 0,
        right: 0
    };

    // #ifdef MP
    // 获取胶囊几何信息
    const capsuleGeometry: UniNamespace.GetMenuButtonBoundingClientRectRes = uni.getMenuButtonBoundingClientRect();

    // 赋值胶囊几何数据
    Object.assign(geometry, capsuleGeometry);
    // #endif

    return {...geometry};
}

/**
 * 获取状态栏高度
 * @returns {number} 返回状态栏高度
 * */
export function getStatusBarHeight(): number
{
    // 状态栏高度
    let statusBarHeight: number = 0;

    // #ifdef MP
    // 当前小程序的胶囊几何信息
    const capsule = getCapsuleGeometry();

    // 因为小程序可以直接使用胶囊位置的top值，所以这里不需要再计算了
    statusBarHeight = capsule.top;
    // #endif

    // #ifndef MP
    // 获取窗体参数
    const windowInfo: UniNamespace.GetWindowInfoResult = uni.getWindowInfo();

    if (windowInfo)
    {
        // 获取状态栏高度
        statusBarHeight = windowInfo.statusBarHeight || 0;
    }
    // #endif

    return statusBarHeight;
}

/**
 * 获取当前竖屏正方向下的安全区域的几何信息
 * @returns {object} 返回安全区域
 * */
export function getSafeAreaGeometry(): {top: number, left: number, width: number, height: number; bottom: number; right: number;}
{
    // 当前竖屏正方向下的安全区域的结合数据
    const geometry: {top: number, left: number, width: number, height: number; bottom: number; right: number;} = {
        top: 0,
        left: 0,
        width: 0,
        height: 0,
        bottom: 0,
        right: 0
    };

    // 获取窗体参数
    const windowInfo: UniNamespace.GetWindowInfoResult = uni.getWindowInfo();

    if (windowInfo)
    {
        // 当前状态栏高度
        const statusBarHeight: number = getStatusBarHeight();

        // 当前胶囊几何信息
        const capsule = getCapsuleGeometry();

        // 赋值胶囊几何的TOP数据
        geometry.top = statusBarHeight + capsule.height;

        // 赋值胶囊几何的LEFT数据
        geometry.left = windowInfo.safeArea.left || 0;

        // 赋值胶囊几何的WIDTH数据
        geometry.width = windowInfo.windowWidth || 0;

        // 赋值胶囊几何的HEIGHT数据
        geometry.height = windowInfo.windowHeight - statusBarHeight - capsule.height - windowInfo.safeAreaInsets.bottom;

        // 赋值胶囊几何的BOTTOM数据
        geometry.bottom = windowInfo.safeAreaInsets.bottom;

        // 赋值胶囊几何的RIGHT数据
        geometry.right = windowInfo.safeArea.right;
    }

    return {...geometry};
}

/**
 * 获取当前竖屏正方向下的安全区域留白高度
 * @returns {number} 返回安全区域留白高度
 * */
export function getSafeAreaInsets(): number
{
    // 当前竖屏正方向下的安全区域留白高度
    let safeAreaInsets: number = 0;

    // 获取窗体参数
    const windowInfo: UniNamespace.GetWindowInfoResult = uni.getWindowInfo();

    if (windowInfo)
    {
        // 获取安全区域留白高度
        safeAreaInsets = windowInfo.safeAreaInsets.bottom;
    }

    return safeAreaInsets;
}